﻿GAdsManager = function(map, publisherId, adsManagerOptions)
{     
    /// <summary>Creates a new GAdsManager object that requests AdSense ads from Google's servers. (Since 2.85)</summary>
    /// <param name="map" type="String">The map parameter identifies the map on which this GAdsManager should display ads.</param>
    /// <param name="publisherId" type="String">The publisherId parameter specifies the developer's AdSense account.</param>
    /// <param name="adsManagerOptions" type="GAdsManagerOptions">The adsManagerOptions parameter is a GAdsManagerOptions object literal.</param>
}

GAdsManager.prototype =
{   
    // ====================================================================================
    // Methods
    // ====================================================================================
    enable : function()
    {
        /// <summary>Enables fetching of ads. Ads are not fetched by default. (Since 2.85)</summary>
    },
    
    disable : function()
    {
        /// <summary>Disables fetching of ads. (Since 2.85)</summary>
    }
}
﻿GAdsManagerOptions = function() 
{
    /// <field name="maxAdsOnMap" type="Number">The maximum number of ads to show on the map at any time. The default value is 3. (Since 2.85)</field>
    /// <field name="channel" type="String">The AdSense channel used for fetching ads. Channels are an optional feature that AdSense publishers can use to track ad revenue from multiple sources. (Since 2.85)</field>
    /// <field name="minZoomLevel" type="Number">The minimum zoom level at which to show ads. The default value is 6. (Since 2.85)</field>
}

GAdsManagerOptions.prototype =
{   
    // ====================================================================================
    // Properties
    // ====================================================================================
    maxAdsOnMap : null,
    channel : null,
    minZoomLevel : null
}
﻿GBounds = function(points) 
{
	/// <summary>Constructs a rectangle that contains all the given points.</summary>
	/// <param name="points">Points that compose the rectangle.</param>
	/// <field name="minX" type="Number">The x coordinate of the left edge of the rectangle.</field>
	/// <field name="minY" type="Number">The y coordinate of the top edge of the rectangle.</field>
	/// <field name="maxX" type="Number">The x coordinate of the right edge of the rectangle.</field>
	/// <field name="maxY" type="Number">The y coordinate of the bottom edge of the rectangle.</field>
	/// <returns type="Object"></returns>
}

GBounds.prototype = 
{
	toString : function() 
	{
		/// <summary>Returns a string that contains the coordinates of the upper left and the lower right corner points of the box, in this order, separated by comma, surrounded by parentheses.</summary>
		/// <returns type="String"></returns>
	},
	
	equals : function(other) 
	{
		/// <summary>Returns true if all parameters in this rectangle are equal to the parameters of the other. (Since 2.98)</summary>
		/// <param name="other" type="GBounds">GBounds to compare</param>
		/// <returns type="Boolean"></returns>
	},
	
	mid : function() 
	{
		/// <summary>Returns the pixel coordinates of the center of the rectangular area. (Since 2.88)</summary>
		/// <returns type="GPoint"></returns>
	},
	
	min : function() 
	{
		/// <summary>Returns the pixel coordinates of the upper left corner of the rectangular area.</summary>
		/// <returns type="GPoint"></returns>
	},
	
	max : function() 
	{
		/// <summary>Returns the pixel coordinates of the lower right corner of the rectangular area.</summary>
		/// <returns type="GPoint"></returns>
	},
	
	containsBounds : function(other) 
	{
		/// <summary>Returns true if the passed rectangular area is entirely contained in this rectangular area.</summary>
		/// <param name="other" type="GBounds">Possible containing GBounds.</param>
		/// <returns type="Boolean"></returns>
	},
		
	containsPoint : function(point) 
	{
		/// <summary>Returns true if the rectangular area (inclusively) contains the pixel coordinates. (Since 2.88)</summary>
		/// <param name="point" type="GPoint">Possible contained GPoint.</param>
		/// <returns type="Boolean"></returns>
	},
	
	extend : function(point) 
	{
		/// <summary>Enlarges this box so that the point is also contained in this box.</summary>
		/// <param name="point" type="GBounds">GPoint to be contained.</param>
	}
}
﻿GBrowserIsCompatible =  function() 
{
	/// <summary>Returns true if the current browser supports the maps API library.</summary>
	/// <returns type="Boolean"></returns>
}
﻿
﻿
﻿GControl = function(printable, selectable) 
{
	/// <summary>Creates the prototype instance for a new control class. Flag printable indicates that the control should be visible in the print output of the map. Flag selectable indicates that the control will contain text that should be selectable.</summary>
	/// <param name="printable" type="Boolean" optional="true">(optional) Is control printable?</param>
	/// <param name="selectable" type="Boolean" optional="true">(optional) Is control selectable?</param>
	/// <returns type="Object"></returns>
}

GControl.prototype = 
{
	printable: function() 
	{
		/// <summary>Returns to the map if the control should be printable.</summary>
		/// <returns type="Boolean"></returns>
	},
	
	selectable: function() 
	{
		/// <summary>Returns to the map if the control contains selectable text.</summary>
		/// <returns type="Boolean"></returns>
	},
	
	initialize: function(map) 
	{
		/// <summary>Will be called by the map so the control can initialize itself. The control will use the method GMap2.getContainer() to get hold of the DOM element that contains the map, and add itself to it. It returns the added element.</summary>
		/// <param name="map" type="GMap2">The map to initialize.</param>
		/// <returns domElement="true"></returns>
	},
	
	getDefaultPosition: function() 
	{
		/// <summary>Returns to the map the position in the map view at which the control appears by default. This will be overridden by the second argument to GMap2.addControl().</summary>
		/// <returns type="	GControlPosition"></returns>
	}
}

﻿
﻿
﻿
﻿
﻿
﻿GDownloadUrl = function(url, onload, postBody, postContentType) 
{
	/// <summary>Retrieves the resource from the given URL and calls the onload function with the text of the document as first argument, and the HTTP response status code as the second. If the request times out, the onload function may be called instead with null as the first argument and -1 as the second. This function defaults to sending an HTTP GET request. To send an HTTP POST request instead, pass data within the optional postBody argument. If the data being sent is not of type "application/x-www-form-urlencoded," pass the content type as a string in the postContentType argument. This method is subject to cross-site scripting restrictions. Note that this method uses the underlying XmlHttpRequest implementation of the browser.</summary>
	/// <param name="url" type="String">Url of the resource to be downloaded.</param>
	/// <param name="onload" type="String">Callback that will be fire when the resource will be loaded.</param>
	/// <param name="postBody" type="String" optional="true">(Optional) Data of the POST HTTP Request.</param>
	/// <param name="postContentType" type="String" optional="true">(Optional) Type of the data of the POST HTTP Request.</param>
	/// <returns type="Boolean"></returns>
}
﻿
﻿
﻿
﻿
﻿
﻿
﻿
﻿
﻿
﻿G_GOOGLEBAR_LINK_TARGET_BLANK = null;
G_GOOGLEBAR_LINK_TARGET_PARENT = null;
G_GOOGLEBAR_LINK_TARGET_SELF = null;
G_GOOGLEBAR_LINK_TARGET_TOP = null;

﻿
﻿G_GOOGLEBAR_RESULT_LIST_INLINE = null;
G_GOOGLEBAR_RESULT_LIST_SUPPRESS = null;

﻿
﻿GHierarchicalMapTypeControl = function() 
{
	/// <summary>Creates a "nested" map type control for selecting and switching between supported map types via buttons and nested checkboxes.</summary>
	/// <returns type="GControl"></returns>
}

GHierarchicalMapTypeControl.prototype = 
{
	addRelationship: function(parentType,  childType, childText, isDefault)
	{
		/// <summary>Registers a parent/child relationship between map types with the control. If childText is given, it will be displayed next to the checkbox for the child map type instead of its name. If isDefault is true, the child map type will be selected by default. Note that all relationships must be set up before the control is added. (Adding relationships after the control is added will have no effect.) (Since 2.94).</summary>
		/// <param name="parentType" type="GMapType">The parent map type.</param>
		/// <param name="childType" type="GMapType">The child map type.</param>
		/// <param name="childText" type="String" optional="true">(optional) Text to be displayed next to the checkbox for the child map type instead of its name.</param>
		/// <param name="isDefault" type="Boolean" optional="true">(optional) If true, the child map type will be selected by default.</param>
	},
	
	removeRelationship: function(mapType) 
	{
		/// <summary>Removes all relationships involving a map type from the control. (Since 2.94)</summary>
		/// <param name="mapType" type="GMapType">The map type to remove.</param>
	},
	
	clearRelationships: function() 
	{
		/// <summary>Removes all relationships from the control. (Since 2.94)</summary>
	},
	
	printable: function() 
	{
		/// <summary>Returns to the map if the control should be printable.</summary>
		/// <returns type="Boolean"></returns>
	},
	
	selectable: function() 
	{
		/// <summary>Returns to the map if the control contains selectable text.</summary>
		/// <returns type="Boolean"></returns>
	},
	
	initialize: function(map) 
	{
		/// <summary>Will be called by the map so the control can initialize itself. The control will use the method GMap2.getContainer() to get hold of the DOM element that contains the map, and add itself to it. It returns the added element.</summary>
		/// <param name="map" type="GMap2">The map to initialize.</param>
		/// <returns domElement="true"></returns>
	},
	
	getDefaultPosition: function() 
	{
		/// <summary>Returns to the map the position in the map view at which the control appears by default. This will be overridden by the second argument to GMap2.addControl().</summary>
		/// <returns type="	GControlPosition"></returns>
	}
}
﻿GIcon = function(copy, image) 
{
	/// <summary>Creates a new icon object. If another icon is given in the optional copy argument, its properties are copied, otherwise they are left empty. The optional argument image sets the value of the image  property.</summary>
	/// <param name="copy" type="GIcon" optional="true">(optional) The icon to copy. Note that you can use the default Maps icon G_DEFAULT_ICON if you don't want to specify your own.</param>
	/// <param name="image" type="String" optional="true">(optional) The foreground image URL of the icon.</param>
	/// <field name="image" type="String">The foreground image URL of the icon.</field>
	/// <field name="shadow" type="String">The shadow image URL of the icon.</field>
	/// <field name="iconSize" type="GSize">The pixel size of the foreground image of the icon.</field>
	/// <field name="shadowSize" type="GSize">The pixel size of the shadow image.</field>
	/// <field name="iconAnchor" type="GPoint">The pixel coordinate relative to the top left corner of the icon image at which this icon is anchored to the map.</field>
	/// <field name="infoWindowAnchor" type="GPoint">The pixel coordinate relative to the top left corner of the icon image at which the info window is anchored to this icon.</field>
	/// <field name="printImage" type="String">The URL of the foreground icon image used for printed maps. It must be the same size as the main icon image given by image.</field>
	/// <field name="mozPrintImage" type="String">The URL of the foreground icon image used for printed maps in Firefox/Mozilla. It must be the same size as the main icon image given by image.</field>
	/// <field name="printShadow" type="String">The URL of the shadow image used for printed maps. It should be a GIF image since most browsers cannot print PNG images.</field>
	/// <field name="transparent" type="String">The URL of a virtually transparent version of the foreground icon image used to capture click events in Internet Explorer. This image should be a 24-bit PNG version of the main icon image with 1% opacity, but the same shape and size as the main icon.</field>
	/// <field name="imageMap" type="elementInteger">An array of integers representing the x/y coordinates of the image map we should use to specify the clickable part of the icon image in browsers other than Internet Explorer.</field>
	/// <field name="maxHeight" type="Number" integer="true">An array of integers representing the x/y coordinates of the image map we should use to specify the clickable part of the icon image in browsers other than Internet Explorer.</field>
	/// <field name="dragCrossImage" type="String">Specifies the cross image URL when an icon is dragged. (Since 2.79)</field>
	/// <field name="dragCrossSize" type="GSize">Specifies the pixel size of the cross image when an icon is dragged. (Since 2.79)</field>
	/// <field name="dragCrossAnchor" type="GPoint">Specifies the pixel coordinate offsets (relative to the iconAnchor) of the cross image when an icon is dragged. (Since 2.79)</field>
	/// <returns type="Object"></returns>
}

G_DEFAULT_ICON = {};

GIcon.prototype = 
{
	image: null,
	shadow: null,
	iconSize: null,
	shadowSize: null,
	iconAnchor: null,
	infoWindowAnchor: null,
	printImage: null,
	mozPrintImage: null,
	printShadow: null,
	transparent: null,
	imageMap: null,
	maxHeight: null,
	dragCrossImage: null,
	dragCrossSize: null,
	dragCrossAnchor: null
}
﻿GInfoWindow = function() 
{
	/// <summary>
	///	GInfoWindow has no constructor. It is created by the map and accessed by its method GMap2.getInfoWindow().
	/// </summary>	
}

GInfoWindow.prototype = 
{
	selectTab: function(index) 
	{
		/// <summary>
		///	Selects the tab with the given index. This has the same effect as clicking on the corresponding tab.
		/// </summary>
		/// <param name="index" type="Number" integer="true">The index to select</param>
	},
	
	hide: function() 
	{
		/// <summary>
		///	Makes the info window invisible. NOTE: This doesn't close the info window. It can be made visible again using show().
		/// </summary>
	},
	
	show: function() 
	{
		/// <summary>
		///	Makes the info window visible if its currently invisible.
		/// </summary>
	},
	
	isHidden: function() 
	{
		/// <summary>
		///	Returns true if the info window is hidden. This includes the state that it's closed.
		/// </summary>
		/// <returns type="Boolean"></returns>
	},
	
	reset: function(latlong, tabs, size, offset, selectedTab) 
	{
		/// <summary>
		///	Resets the state of the info window. Each argument may be null and then its value will not be changed from the current value.
		/// </summary>
		/// <param name="latlong" type="GLatLng">The Lat/Long to reset</param>
		/// <param name="tabs" type="GInfoWindowTab">The tabs to reset</param>
		/// <param name="size" type="GSize">The size to reset</param>
		/// <param name="offset" type="GSize" optional="true">(optional) The offset to reset</param>
		/// <param name="selectedTab" type="Number" integer="true">The selected index to reset</param>
	},
	
	getPoint: function() 
	{
		/// <summary>
		///	Returns the geographical point at which the info window is anchored. The tip of the window points to this point on the map, modulo the pixel offset.
		/// </summary>
		/// <returns type="GLatLng"></returns>
	},
	
	getPixelOffset: function() 
	{
		/// <summary>
		///	Returns the offset, in pixels, of the tip of the info window from the point on the map at whose geographical coordinates the info window is anchored.
		/// </summary>
		/// <returns type="GSize"></returns>
	},
	
	getSelectedTab: function() 
	{
		/// <summary>
		///	Returns the index, starting at 0, of the current selected tab.
		/// </summary>
		/// <returns type="Number" integer="true"></returns>
	},
	
	getTabs: function() 
	{
		/// <summary>
		///	Returns the array of tabs in this info window. (Since 2.59)
		/// </summary>
		/// <returns type="GInfoWindowTabs[]"></returns>
	},
	
	getContentContainers: function() 
	{
		/// <summary>
		///	Returns the array of DOM nodes that hold the content of the tabs of this info window. (Since 2.59)
		/// </summary>
		/// <returns type="elementDomElement"></returns>
	},
	
	enableMaximize: function() 
	{
		/// <summary>
		///	Enables maximization of the info window. A maximizable info window expands to fill most of the map with contents specified via the maxContent and maxTitle  properties of GInfoWindowOptions. The info window must have been opened with maxContent or maxTitle options in order for enableMaximize() or disableMaximize  to have any effect. An info window opened with maxContent or maxTitle will have maximization enabled by default. (Since 2.93)
		/// </summary>
	},
	
	disableMaximize: function() 
	{
		/// <summary>
		///	Disables maximization of the info window. The infowindow must have been opened with maxContent or maxTitle options. Note that if the info window is currently opened, this function will remove the maximize buton but will not restore the window to its minimized state. (Since 2.93)
		/// </summary>
	},
	
	maximize: function() 
	{
		/// <summary>
		///	Maximizes the infowindow. The infowindow must have been opened with maxContent or maxTitle options, and it must not have had its maximization disabled through disableMaximize. (Since 2.93).
		/// </summary>
	},
	
	restore: function() 
	{
		/// <summary>
		///	Restores the info window to its default (non-maximized) state. The infowindow must have been opened with maxContent or maxTitle options. (Since 2.93).
		/// </summary>
	}
}
﻿
﻿
﻿GKeyboardHandler = function(map) 
{
	/// <summary>Instantiate this class to add keyboard bindings to a map. The key bindings are the same as for the maps application.</summary>
	/// <param name="map" type="GMap2">The Google map object</param>
}

﻿GLargeMapControl = function() 
{
	/// <summary>Creates a control with buttons to pan in four directions, and zoom in and zoom out, and a zoom slider.</summary>
	/// <returns type="GControl"></returns>
}

GLargeMapControl.prototype = new GControl();
﻿GLatLng = function(lat, lng, unbounded) 
{
	/// <summary>GLatLng is a point in geographical coordinates longitude and latitude. Notice the ordering of latitude and longitude. If the unbounded flag is true, then the numbers will be used as passed, otherwise latitude will be clamped to lie between -90 degrees and +90 degrees, and longitude will be wrapped to lie between -180 degrees and +180 degrees.</summary>
	/// <param name="lat" type="Number" >The latitude coordinate in degrees, as a number between -90 and +90.</param>
	/// <param name="lng" type="Number" >The longitude coordinate in degrees, as a number between -180 and +180.</param>
	/// <param name="unbounded" type="Boolean" >(optional) If true, then the numbers will be used as passed, otherwise latitude will be clamped to lie between -90 degrees and +90 degrees, and longitude will be wrapped to lie between -180 degrees and +180 degrees.</param>
	/// <returns type="Object"></returns>
}

GLatLng.prototype = 
{
	lat: function() 
	{
		/// <summary>Returns the latitude coordinate in degrees, as a number between -90 and +90. If the unbounded flag was set in the constructor, this coordinate can be outside this interval.</summary>
		/// <returns type="Number"></returns>
	},
	
	lng: function() 
	{
		/// <summary>Returns the longitude coordinate in degrees, as a number between -180 and +180. If the unbounded flag was set in the constructor, this coordinate can be outside this interval.</summary>
		/// <returns type="Number"></returns>
	},
	
	latRadians: function() 
	{
		/// <summary>Returns the latitude coordinate in radians, as a number between -PI/2 and +PI/2. If the unbounded flag was set in the constructor, this coordinate can be outside this interval.</summary>
		/// <returns type="Number"></returns>
	},
	
	lngRadians: function() 
	{
		/// <summary>Returns the longitude coordinate in radians, as a number between -PI and +PI. If the unbounded flag was set in the constructor, this coordinate can be outside this interval.</summary>
		/// <returns type="Number"></returns>
	},
	
	equals: function(other) 
	{
		/// <summary>Returns true iff the other size has equal components, within certain roundoff margins.</summary>
		/// <param name="other" type="GLatLng">The Lat/Long to compare.</param>
		/// <returns type="Boolean"></returns>
	},
	
	distanceFrom: function(other, radius) 
	{
		/// <summary>Returns the distance, in meters, from this point to the given point. By default, this distance is calculated given the default equatorial earth radius of 6378137 meters. The earth is approximated as a sphere, hence the distance could be off as much as 0.3%, especially in the polar extremes. You may also pass an optional radius  argument to calculate distances between GLatLng coordinates on spheres of a different radius than earth. (Since 2.89).</summary>
		/// <param name="other" type="GLatLng">The Lat/Long to compare.</param>
		/// <param name="radius" type="Number" optional="true">(optional) The radus to calculate distances between.</param>
		/// <returns type="Number"></returns>
	},
	
	toUrlValue: function(precision) 
	{
		/// <summary>Returns a string that represents this point in a format suitable for use as a URL parameter value, separated by a comma, without whitespace. By default, precision is returned to 6 digits, which corresponds to a resolution to 4 inches/ 11 centimeters. An optional precision  parameter allows you to specify a lower precision to reduce server load. Note: prior to 2.78, this  precision parameter was not available. (Since 2.78).</summary>
		/// <param name="precision" type="Number" optional="true">(optional) The precision to return.</param>
		/// <returns type="String"></returns>
	}
}
﻿
﻿
﻿GMap2 = function(container, opts)
{
    /// <summary>Creates a new map inside of the given HTML container, which is typically a DIV element.</summary>
    /// <param name="container" type="String">Required. The ID of the HTML control that will contain the map.</param>
    /// <param name="opts" type="GMapOptions">Options of the map.</param>       
}

GMap2.prototype =
{   
    // ====================================================================================
    // Methods
    // ====================================================================================
    enableDragging : function()
    {
        /// <summary>Enables the dragging of the map (enabled by default).</summary>
    },
    
    disableDragging : function()
    {
        /// <summary>Disables the dragging of the map.</summary>
    },
    
    draggingEnabled : function()
    {
        /// <summary>Returns true if the dragging of the map is enabled.</summary>
        /// <returns type="Boolean"></returns>
    },
    
    enableInfoWindow : function()
    {
        /// <summary>Enables info window operations on the map (enabled by default).</summary>
    },
    
    disableInfoWindow : function()
    {
        /// <summary>Closes the info window, if it is open, and disables the opening of a new info window.</summary>
    },
    
    infoWindowEnabled : function()
    {
        /// <summary>Returns true iff the info window is enabled.</summary>
        /// <returns type="Boolean"></returns>
    },
    
    enableDoubleClickZoom : function()
    {
        /// <summary>Enables info window operations on the map (enabled by default).</summary>
        ///none	Enables double click to zoom in and out (disabled by default). (Since 2.58)
    },
    
    disableDoubleClickZoom : function()
    {
        /// <summary>Disables double click to zoom in and out. (Since 2.58)</summary>
    },
    
    doubleClickZoomEnabled : function()
    {
        /// <summary>Returns true if double click to zoom is enabled. (Since 2.58)</summary>
        /// <returns type="Boolean"></returns>
    },
    
    enableContinuousZoom : function()
    {
        /// <summary>Enables continuous smooth zooming for select browsers (disabled by default). (Since 2.58)</summary>
    },
    
    disableContinuousZoom : function()
    {
        /// <summary>Disables continuous smooth zooming. (Since 2.58)</summary>
    },
    
    continuousZoomEnabled : function()
    {
        /// <summary>Returns true if continuous smooth zooming is enabled. (Since 2.58)</summary>
        /// <returns type="Boolean"></returns>
    },
    
    enableGoogleBar : function()
    {
        /// <summary>Enables the GoogleBar, an integrated search control, to the map. When enabled, this control takes the place of the default Powered By Google logo. Note that this control is not enabled by default. (Since 2.92)</summary>
    },
    
    disableGoogleBar : function()
    {
        /// <summary>Disables the GoogleBar integrated search control. When disabled, the default Powered by Google logo occupies the position formerly containing this control. Note that this control is already disabled by default. (Since 2.92)</summary>
    },
    
    enableScrollWheelZoom : function()
    {
        /// <summary>Enables zooming using a mouse's scroll wheel. Note: scroll wheel zoom is disabled by default. (Since 2.78)</summary>
    },
    
    disableScrollWheelZoom : function()
    {
        /// <summary>Disables zooming using a mouse's scroll wheel. Note: scroll wheel zoom is disabled by default. (Since 2.78)</summary>
    },
    
    scrollWheelZoomEnabled : function()
    {
        /// <summary>Returns a Boolean indicating whether scroll wheel zooming is enabled. (Since 2.78)</summary>
        /// <returns type="Boolean"></returns>
    },
    
    
    
    // ====================================================================================
    // Modify the Map Types
    // ====================================================================================
    
    getMapTypes : function() 
    {
		/// <summary>Returns the array of map types registered with this map.</summary>
		/// <returns type="GMapType[]"></returns>
	},
	
	getCurrentMapType : function() 
	{
		/// <summary>Returns the currently selected map type.</summary>
		/// <returns type="GMapType"></returns>
	},
	
	setMapType : function(type) 
	{
		/// <summary>Selects the given new map type. The type must be known to the map. See the constructor, and the method addMapType().</summary>
		/// <param name="type" type="GMapType">The map type to set</param>
	},
	
	addMapType : function(type) 
	{
		/// <summary>Adds a new map type to the map. See section GMapType for how to define custom map types.</summary>
		/// <param name="type" type="GMapType">The map type to add</param>
	},
	
	removeMapType : function(type) 
	{
		/// <summary>Removes the map type from the map. Will update the set of buttons displayed by the GMapTypeControl or GHierarchicalMapTypeControl and fire the removemaptype event.</summary>
		/// <param name="type" type="GMapType">The map type to remove</param>
	},
    
    
    
    // ====================================================================================
    // Map Types
    // ====================================================================================
    
    isLoaded : function() 
    {
		/// <summary>Returns true if the map was initialized by setCenter() since it was created.</summary>
		/// <returns type="Boolean"></returns>
	},
	
	getCenter : function() 
	{
		/// <summary>Returns the geographical coordinates of the center point of the map view.</summary>
		/// <returns type="GLatLng"></returns>
	},
	
	getBounds: function() 
	{
		/// <summary>Returns the the visible rectangular region of the map view in geographical coordinates.</summary>
		/// <returns type="GLatLngBounds"></returns>
	},
	
	getBoundsZoomLevel: function(bounds) 
	{
		/// <summary>Returns the zoom level at which the given rectangular region fits in the map view. The zoom level is computed for the currently selected map type. If no map type is selected yet, the first on the list of map types is used.</summary>
		/// <returns type="Number" integer="true"></returns>
		/// <param name="bounds" type="GLatLngBounds">The lat/long bounds</param>
	},
	
	getSize: function() 
	{
		/// <summary>Returns the size of the map view in pixels.</summary>
		/// <returns type="GSize"></returns>
	},
	
	getZoom: function() 
	{
		/// <summary>Returns the current zoom level.</summary>
		/// <returns type="Number"></returns>
	},
	
	getDragObject: function() 
	{
		/// <summary>Returns the draggable object used by this map. (Since 2.93)</summary>
		/// <returns type="GDraggableObject"></returns>
	},	
    
    
    
    // ====================================================================================
    // Modify the Map State
    // ====================================================================================
    
    setCenter : function(center, zoom, type)
    {
        /// <summary>Sets the map view to the given center. Optionally, also sets zoom level and map type.</summary>
        /// <param name="center" type="GLatLng">An GLatLng element of the center</param>
        /// <param name="zoom" type="Number">Zoom level to be applied.</param>
        /// <param name="type" type="GMapType">Map type to be applied. The map type must be known to the map. See the constructor, and the method addMapType().</param>
    },
    
    panTo : function(center)
    {
        /// <summary>Changes the center point of the map to the given point. If the point is already visible in the current map view, change the center in a smooth animation.</summary>
        /// <param name="center" type="GLatLng">An GLatLng element of the center</param>
    }, 
    
    panBy : function(distance)
    {
        /// <summary>Starts a pan animation by the given distance in pixels.</summary>
        /// <param name="distance" type="Number">Given distance in pixels</param>
    },  
    
    panDirection : function(dx, dy)
    {
        /// <summary>Starts a pan animation by half the width of the map in the indicated directions. +1 is right and down, -1 is left and up, respectively.</summary>
        /// <param name="dx" type="Number"></param>
        /// <param name="dy" type="Number"></param>
    },
    
    setZoom : function(level)
    {
        /// <summary>Sets the zoom level to the given new value.</summary>
        /// <param name="level" type="Number">Zoom level to be applied</param>
    }, 
    
    zoomIn : function()
    {
        /// <summary>Increments zoom level by one.</summary>
    },  
    
    zoomOut : function()
    {
        /// <summary>Decrements zoom level by one.</summary>
    },
    
    savePosition : function()
    {
        /// <summary>Stores the current map position and zoom level for later recall by returnToSavedPosition().</summary>
    }, 
    
    returnToSavedPosition : function()
    {
        /// <summary>Restores the map view that was saved by savePosition().</summary>
    },
    
    checkResize : function()
    {
        /// <summary>Notifies the map of a change of the size of its container. Call this method after the size of the container DOM object has changed, so that the map can adjust itself to fit the new size.</summary>
    },
    
    
    
    // ====================================================================================
    // Overlays
    // ====================================================================================
    addOverlay : function(overlay)
    {
        /// <summary>Adds an overlay to the map and fires the addoverlay event.</summary>
        /// <param name="overlay" type="GOverlay">All objects that implements GOverlay interface : GMarker, GPolyline, GTileLayerOverlay or GInfoWindow</param>
    }, 
    
    removeOverlay : function(overlay)
    {
        /// <summary>Removes the overlay from the map. If the overlay was on the map, it fires the removeoverlay event.</summary>
        /// <param name="overlay" type="GOverlay">All objects that implements GOverlay interface : GMarker, GPolyline, GTileLayerOverlay or GInfoWindow</param>
    },
    
    clearOverlays : function()
    {
        /// <summary>Removes all overlay from the map, and fires the clearoverlays event.</summary>
    },
    
    getPane : function(pane)
    {
        /// <summary>Returns a DIV that holds the object in the layer identified by pane.</summary>
        /// <param name="pane" type="String">Layer that contains the object</param>
        /// <returns type="Node"></returns>
    },
    
    
    
    // ====================================================================================
    // Coordinate Transformations
    // ====================================================================================
    fromContainerPixelToLatLng : function(pixel)
    {
        /// <summary>Computes the geographical coordinates of the point at the given pixel coordinates in the DOM element that contains the map on the page.</summary>
        /// <param name="pixel" type="GPoint">Pixel coordinates in the DOM element that contains the map.</param>
        /// <returns type="GLatLng"></returns>
    },
    
    fromLatLngToContainerPixel : function(latlng)
    {
        /// <summary>Computes the pixel coordinates of the given geographical point in the DOM element that contains the map on the page. (Since 2.100)</summary>
        /// <param name="latlng" type="GLatLng">Geographical point.</param>
        /// <returns type="GPoint"></returns>
    },
    
    fromLatLngToDivPixel : function(latlng)
    {
        /// <summary>Computes the pixel coordinates of the given geographical point in the DOM element that holds the draggable map. You need this method to position a custom overlay when you implement the GOverlay.redraw() method for a custom overlay.</summary>
        /// <param name="latlng" type="GLatLng">Geographical point.</param>
        /// <returns type="GPoint"></returns>
    },
    
    fromDivPixelToLatLng : function(pixel)
    {
        /// <summary>Computes the geographical coordinates from pixel coordinates in the div that holds the draggable map. This may be helpful for when you implement interaction with custom overlays that don't extend the GOverlay interface. If this doesn't give you the expected output, try the fromContainerPixelToLatLng method instead.</summary>
        /// <param name="pixel" type="GPoint">Pixel coordinates in the DIV that holds the draggable map.</param>
        /// <returns type="GLatLng"></returns>
    },
    
    
    
    // ====================================================================================
    // Info Window
    // ====================================================================================
    openInfoWindow : function(latlng, node, opts)
    {
        /// <summary>Opens a simple info window at the given point.</summary>
        /// <param name="latlng" type="GLatLng">Geographical Point.</param>
        /// <param name="node" type="String">The content of the info window is given as a DOM node.</param>
        /// <param name="opts"></param>
    },
    
    openInfoWindowHtml : function(latlng, html, opts)
    {
        /// <summary>Opens a simple info window at the given point.</summary>
        /// <param name="latlng" type="GLatLng">Geographical Point.</param>
        /// <param name="html" type="String">The content of the info window is given as HTML text.</param>
        /// <param name="opts"></param>
    },
    
    openInfoWindowTabs : function(latlng, html, opts)
    {
        /// <summary>Opens a tabbed info window at the given point.</summary>
        /// <param name="latlng" type="GLatLng">Geographical Point.</param>
        /// <param name="tabs" type="String">The content of the info window is given as DOM nodes.</param>
        /// <param name="opts"></param>
    },
    
    openInfoWindowTabsHtml : function(latlng, html, opts)
    {
        /// <summary>Opens a simple info window at the given point.</summary>
        /// <param name="latlng" type="GLatLng">Geographical Point.</param>
        /// <param name="html" type="String">The content of the info window is given as HTML text.</param>
        /// <param name="opts"></param>
    },
    
    showMapBlowup : function(latlng, opts)
    {
        /// <summary>Opens an info window at the given point that contains a closeup view on the map around this point.</summary>
        /// <param name="latlng" type="GLatLng">Geographical Point.</param>
        /// <param name="opts"></param>
    },
    
    updateCurrentTab : function(modifier, onupdate)
    {
        /// <summary>Updates the content of the currently open GInfoWindow object, without repositioning. The info window is resized to fit the new content. (Since 2.85)</summary>
        /// <param name="modifier">The modifier function is used to modify the currently selected tab and is passed a GInfoWindowTab as an argument.</param>
        /// <param name="onupdate">The optional onupdate callback function is called after the info window displays the new content.</param>
    },
    
    clearOverlays : function()
    {
        /// <summary>Closes the currently open info window.</summary>
    },
    
    getInfoWindow : function()
    {
        /// <summary>Returns the info window object of this map. If no info window exists yet, it is created, but not displayed. This operation is not influenced by enableInfoWindow().</summary>
        /// <returns type="GInfoWindow"></returns>
    }    
}

﻿GMapOptions = function()
{
    /// <summary>Creates a new map inside of the given HTML container, which is typically a DIV element.</summary>
    /// <field name="size" type="GSize">Sets the size in pixels of the map.</field>
    /// <field name="mapTypes" type="GMapType[]">Array of map types to be used by this map. By default, G_DEFAULT_MAP_TYPES is used.</field>       
    /// <field name="draggableCursor" type="String">The cursor to display when the map is draggable. (Since 2.59)</field>
    /// <field name="draggingCursor" type="String">The cursor to display while dragging the map. (Since 2.59)</field>
    /// <field name="googleBarOptions" type="GGoogleBarOptions">This property specifies the options to configure the GGoogleBar search control.</field>
}

GMapOptions.prototype =
{   
    size : null,
    mapTypes : null,
    draggableCursor : null,
    draggingCursor : null,
    googleBarOptions : null,
    
    
    toString : function()
    {
        /// <summary>Returns a string that contains the wdith and height parameter, in this order, separated by a comma.</summary>
        /// <returns type="String"></returns>
    }
}


﻿G_MAP_MAP_PANE = null;
G_MAP_MARKER_SHADOW_PANE = null;
G_MAP_MARKER_PANE = null;
G_MAP_FLOAT_SHADOW_PANE = null;
G_MAP_MARKER_MOUSE_TARGET_PANE = null;
G_MAP_FLOAT_PANE = null;

﻿GMapTypeControl = function(useShortNames) 
{
	/// <summary>Creates a standard map type control for selecting and switching between supported map types via buttons.</summary>
	/// <param name="useShortNames" type="Boolean" optional="true">(Optional) If true use the short (alt) names for the map types else long names by default.</param>
	/// <returns type="GControl"></returns>
}

GMapTypeControl.prototype = new GControl();
﻿GMarker = function(latlong, opts) {
	/// <summary>
	///	1. GMarker(latlng, opts) - Creates a marker at the latlng with options specified in GMarkerOptions. By default markers are clickable & have the default icon G_DEFAULT_ICON. (Since 2.50).
	///	2. GMarker(latlong, icon, inert) - Creates a marker at the passed latlng of either GPoint or GLatLng with icon or the G_DEFAULT_ICON. If the inert flag is true, then the marker is not clickable and will not fire any events. (Deprecated since 2.50).
	/// </summary>
	/// <returns type="Object"></returns>
	/// <param name="latlong" type="GLatLng" >The Lat/Long of the marker</param>
	/// <param name="opts" type="GMarkerOptions" optional="true">(optional) The options as javascript object literal. Options are:
		/// 1. icon: GIcon - Selects the tab with the given index, starting at 0, instead of the first tab (with index 0).
		///	2. dragCrossMove: Boolean - Maximum width of the info window content, in pixels.
		/// 3. title: String - Indicates whether or not the info window should close for a click on the map that was not on a marker. If set to true, the info window will not close when the map is clicked. The default value is false. (Since 2.83).
		/// 4. clickable: Boolean - Function is called after the info window is opened and the content is displayed.
		/// 5. draggable: Boolean - Function is called when the info window is closed.
		/// 6. bouncy: Boolean - Pertinent for showMapBlowup() only. The zoom level of the blowup map in the info window.
		/// 7. bounceGravity: Number - Pertinent for showMapBlowup() only. The map type of the blowup map in the info window.
		/// 8. autoPan: Boolean - Specifies content to be shown when the infowindow is maximized. The content may be either an HTML String or an HTML DOM element. (Since 2.93).
		/// 9. zIndexProcess: function - Specifies title to be shown when the infowindow is maximized. The content may be either an HTML String or an HTML DOM element. (Since 2.93).
		/// </param>
}

GMarker.prototype = 
{
	openInfoWindow: function(content, opts) 
	{
		/// <summary>
		///	Opens the map info window over the icon of the marker. The content of the info window is given as a DOM node. Only option GInfoWindowOptions.maxWidth is applicable.
		/// </summary>
		/// <param name="content" domElement="true">The contents of the window</param>
		/// <param name="opts" type="GInfoWindowOptions" optional="true">(optional) The options as javascript object literal. Options are:
		/// 1. maxWidth: Number - Maximum width of the info window content, in pixels.
		/// </param>
	},
	
	openInfoWindowHtml: function(content, opts) 
	{
		/// <summary>
		///	Opens the tabbed map info window over the icon of the marker. The content of the info window is given as an array of tabs that contain the tab content as DOM nodes. Only options GInfoWindowOptions.maxWidth and InfoWindowOptions.selectedTab are applicable.
		/// </summary>
		/// <param name="content" type="String">The contents of the window as html text</param>
		/// <param name="opts" type="GInfoWindowOptions" optional="true">(optional) The options as javascript object literal. Options are:
		/// 1. maxWidth: Number - Maximum width of the info window content, in pixels.
		/// 2. selectedTab: Number - Selects the tab with the given index, starting at 0, instead of the first tab (with index 0).
		/// </param>
	},
	
	openInfoWindowTabs: function(tabs, opts)
	{
		/// <summary>
		///	Opens the tabbed map info window over the icon of the marker. The content of the info window is given as an array of tabs that contain the tab content as DOM nodes. Only options GInfoWindowOptions.maxWidth and InfoWindowOptions.selectedTab are applicable.
		/// </summary>
		/// <param name="tabs" type="GInfoWindowTab[]">The tabs</param>
		/// <param name="opts" type="GInfoWindowOptions" optional="true">(optional) The options as javascript object literal. Options are:
		/// 1. maxWidth: Number - Maximum width of the info window content, in pixels.
		/// 2. selectedTab: Number - Selects the tab with the given index, starting at 0, instead of the first tab (with index 0).
		/// </param>
	},
	
	openInfoWindowTabsHtml: function(tabs, opts) 
	{
		/// <summary>
		///	Opens the tabbed map info window over the icon of the marker. The content of the info window is given as an array of tabs that contain the tab content as Strings that contain HTML text. Only options InfoWindowOptions.maxWidth and InfoWindowOptions.selectedTab are applicable.
		/// </summary>
		/// <param name="tabs" type="GInfoWindowTab[]">The tabs</param>
		/// <param name="opts" type="GInfoWindowOptions" optional="true">(optional) The options as javascript object literal. Options are:
		/// 1. maxWidth: Number - Maximum width of the info window content, in pixels.
		/// 2. selectedTab: Number - Selects the tab with the given index, starting at 0, instead of the first tab (with index 0).
		/// </param>
	},
	
	bindInfoWindow: function(content, opts) 
	{
		/// <summary>
		///	Binds the given DOM node to this marker. The content within this node will be automatically displayed in the info window when the marker is clicked. Pass content as null to unbind. (Since 2.85).
		/// </summary>
		/// <param name="content" domElement="true">The contents</param>
		/// <param name="opts" type="GInfoWindowOptions" optional="true">(optional) The options as javascript object literal. Options are:
		/// 1. selectedTab: Number - Selects the tab with the given index, starting at 0, instead of the first tab (with index 0).
		///	2. maxWidth: Number - Maximum width of the info window content, in pixels.
		/// 3. noCloseOnClick: Boolean - Indicates whether or not the info window should close for a click on the map that was not on a marker. If set to true, the info window will not close when the map is clicked. The default value is false. (Since 2.83).
		/// 4. onOpenFn: function - Function is called after the info window is opened and the content is displayed.
		/// 5. onCloseFn: function - Function is called when the info window is closed.
		/// 6. zoomLevel: Number - Pertinent for showMapBlowup() only. The zoom level of the blowup map in the info window.
		/// 7. mapType: GMapType - Pertinent for showMapBlowup() only. The map type of the blowup map in the info window.
		/// 8. maxContent: String - Specifies content to be shown when the infowindow is maximized. The content may be either an HTML String or an HTML DOM element. (Since 2.93).
		/// 9. maxTitle: String - Specifies title to be shown when the infowindow is maximized. The content may be either an HTML String or an HTML DOM element. (Since 2.93).
		/// 10. pixelOffset: GSize - Specifies a number of pixels in the up (x) and right (y) direction to move the infowindow away from the given GLatLng. (Since 2.98).
		/// </param>
	},
	
	bindInfoWindowHtml: function(content, opts)
	{
		/// <summary>
		///	Binds the given HTML to this marker. The HTML content will be automatically displayed in the info window when the marker is clicked. Pass content as null to unbind. (Since 2.85)
		/// </summary>
		/// <param name="content" type="String">The contents as HTML text.</param>
		/// <param name="opts" type="GInfoWindowOptions" optional="true">(optional) The options as javascript object literal. Options are:
		/// 1. selectedTab: Number - Selects the tab with the given index, starting at 0, instead of the first tab (with index 0).
		///	2. maxWidth: Number - Maximum width of the info window content, in pixels.
		/// 3. noCloseOnClick: Boolean - Indicates whether or not the info window should close for a click on the map that was not on a marker. If set to true, the info window will not close when the map is clicked. The default value is false. (Since 2.83).
		/// 4. onOpenFn: function - Function is called after the info window is opened and the content is displayed.
		/// 5. onCloseFn: function - Function is called when the info window is closed.
		/// 6. zoomLevel: Number - Pertinent for showMapBlowup() only. The zoom level of the blowup map in the info window.
		/// 7. mapType: GMapType - Pertinent for showMapBlowup() only. The map type of the blowup map in the info window.
		/// 8. maxContent: String - Specifies content to be shown when the infowindow is maximized. The content may be either an HTML String or an HTML DOM element. (Since 2.93).
		/// 9. maxTitle: String - Specifies title to be shown when the infowindow is maximized. The content may be either an HTML String or an HTML DOM element. (Since 2.93).
		/// 10. pixelOffset: GSize - Specifies a number of pixels in the up (x) and right (y) direction to move the infowindow away from the given GLatLng. (Since 2.98).
		/// </param>
	},
	
	bindInfoWindowTabs: function(tabs, opts) 
	{
		/// <summary>
		///	Binds the given GInfoWindowTabs (provided as DOM nodes) to this marker. The content within these tabs' nodes will be automatically displayed in the info window when the marker is clicked. Pass tabs as null to unbind. (Since 2.85).
		/// </summary>
		/// <param name="tabs" type="GInfoWindowTab[]">The tabs</param>
		/// <param name="opts" type="GInfoWindowOptions" optional="true">(optional) The options as javascript object literal. Options are:
		/// 1. selectedTab: Number - Selects the tab with the given index, starting at 0, instead of the first tab (with index 0).
		///	2. maxWidth: Number - Maximum width of the info window content, in pixels.
		/// 3. noCloseOnClick: Boolean - Indicates whether or not the info window should close for a click on the map that was not on a marker. If set to true, the info window will not close when the map is clicked. The default value is false. (Since 2.83).
		/// 4. onOpenFn: function - Function is called after the info window is opened and the content is displayed.
		/// 5. onCloseFn: function - Function is called when the info window is closed.
		/// 6. zoomLevel: Number - Pertinent for showMapBlowup() only. The zoom level of the blowup map in the info window.
		/// 7. mapType: GMapType - Pertinent for showMapBlowup() only. The map type of the blowup map in the info window.
		/// 8. maxContent: String - Specifies content to be shown when the infowindow is maximized. The content may be either an HTML String or an HTML DOM element. (Since 2.93).
		/// 9. maxTitle: String - Specifies title to be shown when the infowindow is maximized. The content may be either an HTML String or an HTML DOM element. (Since 2.93).
		/// 10. pixelOffset: GSize - Specifies a number of pixels in the up (x) and right (y) direction to move the infowindow away from the given GLatLng. (Since 2.98).
		/// </param>
	},
	
	bindInfoWindowTabsHtml: function(tabs, opts) 
	{
		/// <summary>
		///	Binds the given GInfoWindowTabs (provided as strings of HTML) to this marker. The HTML content within these tabs will be automatically displayed in the info window when the marker is clicked. Pass tabs as null  to unbind. (Since 2.85).
		/// </summary>
		/// <param name="tabs" type="GInfoWindowTab[]">The tabs</param>
		/// <param name="opts" type="GInfoWindowOptions" optional="true">(optional) The options as javascript object literal. Options are:
		/// 1. selectedTab: Number - Selects the tab with the given index, starting at 0, instead of the first tab (with index 0).
		///	2. maxWidth: Number - Maximum width of the info window content, in pixels.
		/// 3. noCloseOnClick: Boolean - Indicates whether or not the info window should close for a click on the map that was not on a marker. If set to true, the info window will not close when the map is clicked. The default value is false. (Since 2.83).
		/// 4. onOpenFn: function - Function is called after the info window is opened and the content is displayed.
		/// 5. onCloseFn: function - Function is called when the info window is closed.
		/// 6. zoomLevel: Number - Pertinent for showMapBlowup() only. The zoom level of the blowup map in the info window.
		/// 7. mapType: GMapType - Pertinent for showMapBlowup() only. The map type of the blowup map in the info window.
		/// 8. maxContent: String - Specifies content to be shown when the infowindow is maximized. The content may be either an HTML String or an HTML DOM element. (Since 2.93).
		/// 9. maxTitle: String - Specifies title to be shown when the infowindow is maximized. The content may be either an HTML String or an HTML DOM element. (Since 2.93).
		/// 10. pixelOffset: GSize - Specifies a number of pixels in the up (x) and right (y) direction to move the infowindow away from the given GLatLng. (Since 2.98).
		/// </param>
	},
	
	closeInfoWindow: function() 
	{
		/// <summary>
		///	Closes the info window only if it belongs to this marker. (Since 2.85).
		/// </summary>
	},
	
	showMapBlowup: function(opts) 
	{
		/// <summary>
		///		Opens the map info window over the icon of the marker. The content of the info window is a closeup map around the marker position. Only options InfoWindowOptions.zoomLevel  and InfoWindowOptions.mapType are applicable.
		/// </summary>
		/// <param name="opts" type="GInfoWindowOptions" optional="true">(optional) The options as javascript object literal. Options are:
		/// 1. zoomLevel: Number - Pertinent for showMapBlowup() only. The zoom level of the blowup map in the info window.
		/// 2. mapType: GMapType - Pertinent for showMapBlowup() only. The map type of the blowup map in the info window.
		/// </param>
	},
	
	getIcon: function() 
	{
		/// <summary>
		///	Returns the icon of this marker, as set by the constructor.
		/// </summary>
		/// <returns type="GIcon"></returns>
	},
	
	getTitle: function() 
	{
		/// <summary>
		///	Returns the title of this marker, as set by the constructor via the GMarkerOptions.title property. Returns undefined if no title is passed in. (Since 2.85)
		/// </summary>
		/// <returns type="String"></returns>
	},
	
	getPoint: function() 
	{
		/// <summary>
		///	Returns the geographical coordinates at which this marker is anchored, as set by the constructor or by setPoint(). (Deprecated since 2.88).
		/// </summary>
		/// <returns type="GLatLng"></returns>
	},
	
	getLatLng: function() 
	{
		/// <summary>
		///	Returns the geographical coordinates at which this marker is anchored, as set by the constructor or by setLatLng(). (Since 2.88).
		/// </summary>
		/// <returns type="GLatLng"></returns>
	},
	
	setPoint: function(latlng) 
	{
		/// <summary>
		///	Sets the geographical coordinates of the point at which this marker is anchored. (Deprecated since 2.88).
		/// </summary>
		/// <param name="latlng" type="GLatLng">The Lat/Long to set.</param>
	},
	
	setLatLng: function(latlng) 
	{
		/// <summary>
		///	Sets the geographical coordinates of the point at which this marker is anchored. (Since 2.88).
		/// </summary>
		/// <param name="latlng" type="GLatLng">The Lat/Long to set.</param>
	},
	
	enableDragging: function() 
	{
		/// <summary>
		///	Enables the marker to be dragged and dropped around the map. To function, the marker must have been initialized with GMarkerOptions.draggable = true.
		/// </summary>
	},
	
	disableDragging: function() 
	{
		/// <summary>
		///	Disables the marker from being dragged and dropped around the map.
		/// </summary>
	},
	
	draggable: function() 
	{
		/// <summary>
		///	Returns true if the marker has been initialized via the constructor using GMarkerOptions.draggable = true. Otherwise, returns false.
		/// </summary>
		/// <returns type="Boolean"></returns>
	},
	
	draggingEnabled: function() 
	{
		/// <summary>
		///	Returns true if the marker is currently enabled for the user to drag on the map.
		/// </summary>
		/// <returns type="Boolean"></returns>
	},
	
	setImage: function(url) 
	{
		/// <summary>
		///	Requests the image specified by the url to be set as the foreground image for this marker. Note that neither the print image nor the shadow image are adjusted. Therefore this method is primarily intended to implement highlighting or dimming effects, rather than drastic changes in marker's appearances. (Since 2.75).
		/// </summary>
		/// <param name="url" type="String">The url of the image.</param>
	},
	
	hide: function() 
	{
		/// <summary>
		///	Hides the marker if it is currently visible. Note that this function triggers the event GMarker.visibilitychanged in case the marker is currently visible. (Since 2.77).
		/// </summary>
	},
	
	show: function() 
	{
		/// <summary>
		///	Shows the marker if it is currently hidden. Note that this function triggers the event GMarker.visibilitychanged in case the marker is currently hidden. (Since 2.77).
		/// </summary>
	},
	
	isHidden: function() 
	{
		/// <summary>
		///	Returns true if the marker is currently hidden. Otherwise returns false. (Since 2.77)
		/// </summary>
	}
}
﻿
﻿
﻿
﻿GMenuMapTypeControl = function(useShortNames) 
{
	/// <summary>Creates a drop-down map type control for switching between supported map types.</summary>
	/// <param name="useShortNames" type="Boolean" optional="true">(Optional) If true use the short (alt) names for the map types else long names by default.</param>
	/// <returns type="GControl"></returns>
}

GMenuMapTypeControl.prototype = new GControl();
﻿
﻿GOverlay = function() 
{
	/// <summary>This interface is implemented by the GMarker, GPolyline, GTileLayerOverlay  and GInfoWindow classes in the maps API library. You can implement it if you want to display custom types of overlay objects on the map. An instance of GOverlay can be put on the map with the method GMap2.addOverlay(). The map will then call the method GOverlay.initialize() on the overlay instance to display itself on the map initially. Whenever the map display changes, the map will call GOverlay.redraw() so that the overlay can reposition itself if necessary. The overlay instance can use the method GMap2.getPane() to get hold of one or more DOM container elements to attach itself to.</summary>
	/// <returns type="Object"></returns>
}

GOverlay.prototype = 
{
	getZIndex: function(latitude) 
	{
		/// <summary>Returns a CSS z-index value for a given latitude. It computes a z index such that overlays further south are on top of overlays further north, thus creating the 3D appearance of marker overlays.</summary>
		/// <returns type="Number" integer="true"></returns>
	}
}
﻿GOverviewMapControl = function() 
{
	/// <summary>Creates a collapsible overview mini-map in the corner of the main map for reference location and navigation (through dragging). The GOverviewMapControl creates an overview map with a one-pixel black border.</summary>
	/// <returns type="	Object"></returns>
}

GOverviewMapControl.prototype = new GControl();
﻿GPoint = function(x, y) 
{
	/// <summary>Creates a GPoint object.</summary>	
	/// <param name="x" type="Number" integer="true"> x coordinate. (This value increases to the right in the Google Maps coordinate system.)</param>
	/// <param name="y" type="Number" integer="true">y coordinate. (This value increases downwards in the Google Maps coordinate system.)</param>
	/// <field name="x" type="Number" integer="true"> x coordinate. (This value increases to the right in the Google Maps coordinate system.)</field>
	/// <field name="y" type="Number" integer="true">y coordinate. (This value increases downwards in the Google Maps coordinate system.)</field>
	/// <returns type="Object"></returns>
}

GPoint.prototype = 
{
	x: null,
	y: null,
	
	equals: function(other) 
	{
		/// <summary>Returns true if the other point has equal coordinates.</summary>
		/// <param name="other" type="GPoint">The point to compare.</param>
		/// <returns type="Boolean"></returns>
	},
	
	toString: function() 
	{
		/// <summary>Returns a string that contains the x and y coordinates, in this order, separated by a comma.</summary>
		/// <returns type="String"></returns>
	}
}
﻿
﻿
﻿
﻿
﻿
﻿
﻿GRoute = function()
{    
    /// <summary>
	///	GRoute has no constructor.
	/// </summary> 
}

GRoute.prototype =
{   
    // ====================================================================================
    // Methods
    // ====================================================================================
    getNumSteps : function()
    {
        /// <summary>Returns the number of steps in this route. (Since 2.81)</summary>
        /// <returns type="Number"></returns>
    },
    
    getStep : function(index)
    {
        /// <summary>Return the GStep object for the index step in this route. (Since 2.81)</summary>
        /// <param name="index" type="Number">Index of the step in this route that we want to retrieve</param>
        /// <returns type="GStep"></returns>
    },
    
    getStartGeocode : function()
    {
        /// <summary>Return the geocode result for the starting point of this route. The structure of this object is identical to that of a single placemark in a response from the GClientGeocoder object. (Since 2.83)</summary>
        /// <returns type="Object"></returns>
    },
    
    getEndGeocode : function()
    {
        /// <summary>Return the geocode result for the ending point of this route. The structure of this object is identical to that of a single placemark in a response from the GClientGeocoder object. (Since 2.83)</summary>
        /// <returns type="Object"></returns>
    },
    
    getEndLatLng : function()
    {
        /// <summary>Returns a GLatLng object for the last point along the polyline for this route. Note that this point may be different from the lat,lng in GRoute.getEndGeocode() because getEndLatLng() always returns a point that is snapped to the road network. There is no corresponding getStartLatLng() method because that is identical to calling GRoute.getStep(0).getLatLng(). (Since 2.81)</summary>
        /// <returns type="GLatLng"></returns>
    },
    
    getSummaryHtml : function()
    {
        /// <summary>Returns an HTML snippet containing a summary of the distance and time for this route. (Since 2.81)</summary>
        /// <returns type="String"></returns>
    },
    
    getDistance : function()
    {
        /// <summary>Returns an object literal representing the total distance of this route. See GDirections.getDistance() for the structure of this object. (Since 2.81)</summary>
        /// <returns type="Object"></returns>
    },
    
    getDuration : function()
    {
        /// <summary>Returns an object literal representing the total time of this route. See GDirections.getDuration() for the structure of this object. (Since 2.81)</summary>
        /// <returns type="Object"></returns>
    }
}
﻿GScaleControl = function() 
{
	/// <summary>Creates a control that displays the map scale.</summary>
	/// <returns type="GControl"></returns>
}

GScaleControl.prototype = new GControl();
﻿
﻿
﻿
﻿GSize = function(width, height)
{
    /// <summary>Creates a GSize object.</summary>
    /// <param name="width" type="Number">The width parameter.</param>
    /// <param name="height" type="Number">The height parameter.</param>
    /// <field name="width" type="Number">The width property.</field>
    /// <field name="height" type="Number">The height property.</field>       
}

GSize.prototype =
{   
    width : null,
    height : null,
    
    equals : function(other)
    {
        /// <summary>Returns true iff the other size has exactly equal components.</summary>
        /// <param name="other" type="Object">Element to be compared.</param> 
        /// <returns type="Boolean"></returns>
    },
    
    toString : function()
    {
        /// <summary>Returns a string that contains the wdith and height parameter, in this order, separated by a comma.</summary>
        /// <returns type="String"></returns>
    }
}

﻿GSmallMapControl = function() 
{
	/// <summary>Creates a control with buttons to pan in four directions, and zoom in and zoom out.</summary>
	/// <returns type="GControl"></returns>
}

GSmallMapControl.prototype = new GControl();
﻿GSmallZoomControl = function() 
{
	/// <summary>Creates a control with buttons to zoom in and zoom out.</summary>
	/// <returns type="GControl"></returns>
}

GSmallZoomControl.prototype = new GControl();
﻿GStep = function()
{     
    /// <summary>
	///	GStep has no constructor.
	/// </summary>	
}

GStep.prototype =
{   
    // ====================================================================================
    // Methods
    // ====================================================================================
    getLatLng : function()
    {
        /// <summary>Returns a GLatLng object for the first point along the polyline for this step. (Since 2.81)</summary>
        /// <returns type="GLatLng"></returns>
    },
    
    getPolylineIndex : function()
    {
        /// <summary>Returns the index of the first point along the polyline for this step. (Since 2.81)</summary>
        /// <returns type="Number"></returns>
    },
    
    getDescriptionHtml : function()
    {
        /// <summary>Return an HTML string containing the description of this step. (Since 2.81)</summary>
        /// <returns type="String"></returns>
    },
    
    getDistance : function()
    {
        /// <summary>Returns an object literal representing the total distance of this step. See GDirections.getDistance() for the structure of this object. (Since 2.81)</summary>
        /// <returns type="Object"></returns>
    },
    
    getDuration : function()
    {
        /// <summary>Returns an object literal representing the total time of this step. See GDirections.getDuration() for the structure of this object. (Since 2.81)</summary>
        /// <returns type="Object"></returns>
    }
}
﻿GStreetviewClient = function()
{     
    /// <summary>Creates a new GStreetviewClient. (Since 2.104)</summary>
}

GStreetviewClient.prototype =
{   
    // ====================================================================================
    // Methods
    // ====================================================================================
    getNearestPanoramaLatLng : function(latlng, callback)
    {
        /// <summary>Finds the GLatLng of the nearest panorama to a given point and passes it to the provided callback. If there are no nearby panoramas, or if a server error occurs, the provided callback is passed null instead. (Since 2.104)</summary>
        /// <param name="latlng" type="GLatLng">Position to search for panorama.</param>
        /// <param name="callback" type="GLatLng">GLatLng of the nearest panorama. If there are no nearby panoramas, or if a server error occurs, the provided callback is passed null instead.</param>
    },
    
    getNearestPanorama : function(latlng, callback)
    {
        /// <summary>Retrieves the data for the nearest panorama to a given latlng and passes it to the provided callback as a GStreetviewData object. (Since 2.104)</summary>
        /// <param name="latlng" type="GLatLng">Position to search for panorama.</param>
        /// <param name="callback" type="GStreetviewData">GLatLng of the nearest panorama. If there are no nearby panoramas, or if a server error occurs, the provided callback is passed null instead.</param>
    },
    
    getPanoramaById : function(panoId, callback)
    {
        /// <summary>Retrieves the data for the given panorama id and passes it to the provided callback as a GStreetviewData object. Ids are unique per panorama and stable for the lifetime of a session, but are liable to change between sessions. (Since 2.104)</summary>
        /// <param name="panoId" type="Number">Panorama ID.</param>
        /// <param name="callback" type="GStreetviewData">Data for the given panorama id.</param>
    }
    
}

﻿
﻿
﻿
﻿
﻿GStreetviewOverlay = function()
{     
    /// <summary>Creates a new GStreetviewOverlay which implements the GOverlay interface. (Since 2.104)</summary>
}

GStreetviewOverlay.prototype =
{

}
﻿
﻿GStreetviewPanorama = function(container, opts)
{     
    /// <summary>Creates a new GStreetviewPanorama object with a corresponding flash viewer in the provided container. The viewer will not be shown until a location has been specified, either in the optional GStreetviewPanoramaOptions opts object or by calling setLocationAndPOV. (Since 2.104)</summary>
    /// <param name="container" type="GSize">Container in which the panorama will be added.</param>
    /// <param name="opts" type="GStreetviewPanoramaOptions">Specification of the location.</param>
}

GStreetviewPanorama.prototype =
{   
    // ====================================================================================
    // Methods
    // ====================================================================================
    remove : function()
    {
        /// <summary>Removes the instance of the flash viewer currently associated with this object from the DOM. This function must be called before removing the HTML container element otherwise some browsers will fail to garbage collect the flash viewer. (Since 2.104)</summary>
    },
    
    setContainer : function(container)
    {
        /// <summary>Sets the container element for the flash viewer, moving the viewer from its old location if it is currently open. (Since 2.104)</summary>
        /// <param name="container" type="String">Container element for the flash viewer.</param>
    },
    
    checkResize : function()
    {
        /// <summary>Notifies the flash viewer of a change of the size of its container. Call this method after the size of the container DOM object has changed, so that the viewer can adjust itself to fit the new size. (Since 2.104)</summary>
    },
    
    hide : function()
    {
        /// <summary>Hides the flash viewer. To remove the viewer, call .remove() instead. (Since 2.104)</summary>
    },
    
    show : function()
    {
        /// <summary>Shows the flash viewer. (Since 2.104)</summary>
    },
    
    isHidden : function()
    {
        /// <summary>Returns true if the flash viewer associated with this object is hidden, otherwise false. (Since 2.104)</summary>
        /// <returns type="Boolean"></returns>
    },
    
    getPOV : function()
    {
        /// <summary>Returns the current point of view (POV) displayed in the flash viewer. (Since 2.104)</summary>
        /// <returns type="GPov"></returns>
    },
    
    setPOV : function(pov)
    {
        /// <summary>Changes the current point of view (POV) displayed in the flash viewer without changing the location. (Since 2.104)</summary>
        /// <param name="pov" type="GPov">Point of view (POV).</param>
    },
    
    panTo : function(pov, opt_longRoute)
    {
        /// <summary>Changes the current point of view (POV) displayed in the flash viewer without changing the location. Performs a smooth animation from the current POV to the new POV. (Since 2.104)</summary>
        /// <param name="pov" type="GPov">New Point of view (POV)</param>
        /// <param name="opt_longRoute" type="Boolean">If opt_longRoute is set then the animation will follow a long route around the sphere, otherwise the shortest route</param>
    },
    
    setLocationAndPOV : function(latlng, opt_pov)
    {
        /// <summary>Sets the location and POV of the flash viewer. After calling this function, the viewer will display the nearest location to the latlng provided if one is available. If no data is available for this location, then the flash player will remain unchanged and emit an error code. See GStreetviewClient.ReturnValues for the possible response codes. (Since 2.104)</summary>
        /// <param name="latlng" type="GLatLng">GLatLng object where the view need to be set.</param>
        /// <param name="opt_pov" type="Boolean">If opt_longRoute is set then the animation will follow a long route around the sphere, otherwise the shortest route</param>
    },
    
    followLink : function(yaw)
    {
        /// <summary>Follows a link from the current panorama to a neighbouring panorama. If there are multiple neighbouring panoramas then the nearest match will be taken. (Since 2.104)</summary>
        /// <param name="yaw" type="Number">Yaw specifies the direction of the neighbouring panorama.</param>
    }
}
﻿GStreetviewPanoramaOptions = function() 
{
    /// <field name="latlng" type="GLatLng">The latlng at which to open the flash viewer. (Since 2.104)</field>
    /// <field name="pov" type="GPov">The camera orientation with which to open the flash viewer. (Since 2.104)</field>
}

GStreetviewPanoramaOptions.prototype =
{   
    // ====================================================================================
    // Properties
    // ====================================================================================
    latlng : null,
    pov : null
}
﻿
﻿
﻿GTrafficOverlay = function()
{     
    /// <summary>Creates a new GTrafficOverlay object that shows road traffic information. (Since 2.81)</summary>
}

GTrafficOverlay.prototype =
{   
    // ====================================================================================
    // Methods
    // ====================================================================================
    hide : function()
    {
        /// <summary>Hides the traffic overlay. (Since 2.81)</summary>
    },
    
    show : function()
    {
        /// <summary>Shows the traffic overlay. (Since 2.81)</summary>
    }
}
﻿GUnload: function() 
{
	/// <summary>Dismantles all registered event handlers in order to prevent memory leaks. Should be called as a handler for the unload event.</summary>
}
﻿GXml = function()
{     
}

GXml.prototype =
{   
    // ====================================================================================
    // Methods
    // ====================================================================================
    parse : function(xmltext)
    {
        /// <summary>Parses the given string as XML text and returns a DOM representation. If the browser doesn't support XML parsing natively, this returns the DOM node of an empty DIV element.</summary>
        /// <param name="xmltext" type="String">XML text to parse</param>
        /// <returns type="Node"></returns>
    },
    
    value : function(xmlnode)
    {
        /// <summary>Returns the text value (i.e., only the plain text content) of the XML document fragment given in DOM representation.</summary>
        /// <param name="xmlnode" type="string">XML document fragment given in DOM representation</param>
        /// <returns type="String"></returns>
    }
}
﻿
﻿GXslt = function()
{     
}

GXslt.prototype =
{   
    // ====================================================================================
    // Methods
    // ====================================================================================
    create : function(xsltnode)
    {
        /// <summary>Creates a GXslt instance from the XSLT stylesheet given as DOM representation.</summary>
        /// <param name="xsltnode" type="String">XSLT stylesheet given as DOM representation.</param>
        /// <returns type="GXslt"></returns>
    },
    
    transformToHtml : function(xmlnode, htmlnode)
    {
        /// <summary>Uses the XSLT stylesheet given in the constructor of this GXslt instance to transform the XML document given as DOM representation in xmlnode. Appends the resulting HTML document fragment to the given htmlnode. This only works if the browser natively supports XSL transformations, in which case it will return true. Otherwise, this function will do nothing and return false.</summary>
        /// <param name="xmlnode" type="string">XML document given as DOM representation.</param>
        /// <param name="xmlnode" type="string">HTML document fragment where result appends.</param>
        /// <returns type="Boolean"></returns>
    }
}
